@codeyam/codeyam-cli 0.1.0-staging.03e0fb2 → 0.1.0-staging.08a490f

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-24T22:52:44.990Z",
-  "buildTime": 1771973564990,
-  "gitCommit": "03e0fb2ed10ce844a1a5215adf9aeb200ef627bb",
-  "nodeVersion": "v20.20.0",
-  "contentHash": "4a186f37ec4532e5a53e13c6fe2b2ce95a580cd45c739dc01a9ed7688ff1f99a",
-  "buildNumber": 704,
-  "semanticVersion": "0.1.704",
-  "version": "0.1.704 (2026-02-24T22:52+4a186f3)"
+  "buildTimestamp": "2026-07-08T17:53:03.922Z",
+  "buildTime": 1783533183922,
+  "gitCommit": "08a490fa4af0e1ebe381f964977af89c7b8fca3d",
+  "nodeVersion": "v20.20.2",
+  "contentHash": "c92230c027acb71cab56d2a696876a6a52206bfadd59fbc31a512b00a7ee8826",
+  "buildNumber": 1353,
+  "semanticVersion": "0.1.1353",
+  "version": "0.1.1353 (2026-07-08T17:53+c92230c)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/24/2026, 10:52:44 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/24/2026, 10:52:44 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[7/8/2026, 5:53:03 PM] > codeyam-combo@1.0.0 mergeDependencies
+[7/8/2026, 5:53:03 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/24/2026, 10:52:44 PM] Merged dependencies into root package.json
+[7/8/2026, 5:53:03 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
     "@aws-sdk/client-cloudfront": "^3.990.0",
-    "@aws-sdk/client-codebuild": "^3.995.0",
+    "@aws-sdk/client-codebuild": "^3.1014.0",
     "@aws-sdk/client-dynamodb": "^3.990.0",
     "@aws-sdk/client-ec2": "^3.990.0",
     "@aws-sdk/client-ecr": "^3.990.0",
@@ -18,7 +18,7 @@
     "@aws-sdk/client-sqs": "^3.990.0",
     "@aws-sdk/lib-storage": "^3.990.0",
     "@aws-sdk/util-dynamodb": "^3.990.0",
-    "@octokit/auth-app": "^8.1.0",
+    "@octokit/auth-app": "^8.2.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
     "@supabase/supabase-js": "2.88.0",
@@ -30,7 +30,7 @@
     "jest": "^30.2.0",
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
-    "lru-cache": "^11.2.5",
+    "lru-cache": "^11.2.7",
     "openai": "^6.16.0",
     "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",
@@ -38,31 +38,31 @@
     "pixelmatch": "^5.3.0",
     "playwright": "1.58.0",
     "sharp": "^0.34.5",
-    "simple-git": "^3.28.0",
+    "simple-git": "^3.32.2",
     "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.74.0",
-    "@aws-sdk/s3-request-presigner": "^3.990.0",
-    "better-sqlite3": "^12.4.1",
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@aws-sdk/s3-request-presigner": "^3.1019.0",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.11",
-    "pg": "^8.16.3",
+    "kysely": "^0.28.14",
+    "pg": "^8.20.0",
     "@octokit/request": "^10.0.3",
-    "lucide-react": "^0.556.0",
+    "lucide-react": "^0.577.0",
     "react-resizable": "^3.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
-    "@types/node": "^25.0.2",
+    "@types/node": "^25.3.3",
     "@types/yargs": "^17.0.34",
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
     "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",

package/analyzer-template/packages/ai/package.json

@@ -9,12 +9,12 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "jsdom": "^27.4.0",
     "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
-    "lru-cache": "^11.2.5"
+    "lru-cache": "^11.2.7"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0"

package/analyzer-template/packages/ai/src/lib/astScopes/astScopeAnalyzer.ts

@@ -909,11 +909,42 @@ export class ASTScopeAnalyzer {
     if (tsType.flags & ts.TypeFlags.Union) {
       const unionType = tsType as ts.UnionType;
 
-      // Check if it's a string literal union
-      const isAllStringLiterals = unionType.types.every(
+      // Check if it's a string literal union (optionally with null/undefined).
+      // Preserve literal values so the LLM knows which values are valid when
+      // generating mock data. Without this, types like
+      // 'suggestion' | 'warning' | 'achievement' | 'tip' become just 'string'
+      // and the LLM generates invalid values (e.g. "Motivational").
+      const stringLiterals = unionType.types.filter(
         (t) => (t.flags & ts.TypeFlags.StringLiteral) !== 0,
       );
-      if (isAllStringLiterals) return 'string';
+      const nullishTypes = unionType.types.filter(
+        (t) =>
+          (t.flags & ts.TypeFlags.Undefined) !== 0 ||
+          (t.flags & ts.TypeFlags.Null) !== 0,
+      );
+
+      if (
+        stringLiterals.length > 0 &&
+        stringLiterals.length + nullishTypes.length === unionType.types.length
+      ) {
+        const literalValues = stringLiterals.map(
+          (t) => `'${(t as ts.LiteralType).value}'`,
+        );
+        const literalUnion = literalValues.join(' | ');
+
+        if (nullishTypes.length > 0) {
+          const nullishParts: string[] = [];
+          if (nullishTypes.some((t) => (t.flags & ts.TypeFlags.Null) !== 0))
+            nullishParts.push('null');
+          if (
+            nullishTypes.some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)
+          )
+            nullishParts.push('undefined');
+          return `${literalUnion} | ${nullishParts.join(' | ')}`;
+        }
+
+        return literalUnion;
+      }
 
       // Check if it's a number literal union
       const isAllNumberLiterals = unionType.types.every(

package/analyzer-template/packages/ai/src/lib/astScopes/methodSemantics.ts

@@ -895,6 +895,132 @@ export class UseStateSemantics implements MethodSemantics {
   }
 }
 
+// ─── Set/Map method semantics ──────────────────────────────────────────
+//
+// Set/Map membership operations (.has, .delete, .add, .get, .set, .clear)
+// don't create data flow equivalencies — they're membership checks or
+// mutations, not transformations that propagate schema structure.
+// Without these semantics, code like `filterRatings.has(articleId)` creates
+// spurious equivalencies (332 entries in the Margo LibraryPage case).
+
+/**
+ * Set.has() / Map.has() — membership check, returns boolean
+ */
+export class CollectionHasSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    context.addType(methodCallPath, 'boolean');
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.delete() / Map.delete() — removal, returns boolean
+ */
+export class CollectionDeleteSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    context.addType(methodCallPath, 'boolean');
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.add() — adds an element, returns the Set (for chaining)
+ */
+export class SetAddSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'object'; // Returns the Set itself
+  }
+
+  addEquivalences(
+    _methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    _context: AnalysisContext,
+  ): void {
+    // No equivalencies — add() doesn't create data flow
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.clear() / Map.clear() — removes all elements, returns void
+ */
+export class CollectionClearSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'void';
+  }
+
+  addEquivalences(): void {
+    // No equivalencies
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Map.get() — retrieves a value by key, returns unknown (value type)
+ */
+export class MapGetSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'unknown';
+  }
+
+  addEquivalences(
+    _methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    _context: AnalysisContext,
+  ): void {
+    // No equivalencies — the return value type depends on the map contents
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Map.set() — sets a key-value pair, returns the Map (for chaining)
+ */
+export class MapSetSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'object'; // Returns the Map itself
+  }
+
+  addEquivalences(): void {
+    // No equivalencies
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
 /**
  * Create and populate the registry with method semantics
  */
@@ -930,6 +1056,15 @@ export function createMethodRegistry(): MethodSemanticsRegistry {
   registry.register('useState', new UseStateSemantics(), 'React');
   registry.register('useMemo', new UseMemoSemantics(), 'React');
 
+  // Register Set/Map collection methods.
+  // Only .has() and .delete() are safe to register by method name — they always
+  // return boolean regardless of the collection type (Set, Map, WeakSet, WeakMap,
+  // FormData, URLSearchParams, etc.).
+  // .add(), .clear(), .get(), .set() are too ambiguous across different types
+  // and can't be registered until the lookup code supports class-aware resolution.
+  registry.register('has', new CollectionHasSemantics());
+  registry.register('delete', new CollectionDeleteSemantics());
+
   return registry;
 }
 

package/analyzer-template/packages/ai/src/lib/astScopes/nodeToSource.ts

@@ -54,6 +54,25 @@ export function nodeToSource(
   //   return serializeBindingElement(node, sourceFile, options);
   // }
 
+  // Object/array/function literals should be marked as literal paths.
+  // This prevents them from creating sourceEquivalencies when used as
+  // function call arguments (e.g., setUndoEntry({ label: '...', undo: ... })).
+  // Without this, the full source text of the literal (300-500 chars for complex
+  // objects) gets embedded in path strings, creating expensive-to-parse
+  // equivalency entries that don't contribute useful schema information.
+  if (ts.isObjectLiteralExpression(node)) {
+    return StructuredPath.createLiteralPath(node.getText(sourceFile), 'object');
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return StructuredPath.createLiteralPath(node.getText(sourceFile), 'array');
+  }
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    return StructuredPath.createLiteralPath(
+      node.getText(sourceFile),
+      'function',
+    );
+  }
+
   // Fallback for unsupported node types
   return StructuredPath.fromBase(node.getText(sourceFile));
 }

package/analyzer-template/packages/ai/src/lib/astScopes/paths.ts

@@ -406,11 +406,18 @@ export class StructuredPath {
           } else {
             // Convert each argument to its string representation
             const argsStr = funcSegment.args
-              .map((arg) =>
-                arg.toStringWithSegments(arg.base, arg.segments, {
+              .map((arg) => {
+                // For literal arguments (object/array/function literals),
+                // use a compact placeholder instead of the full source text.
+                // This prevents 300-500 char inline objects from being embedded
+                // in call signature paths, which creates expensive equivalencies.
+                if (arg.isLiteral()) {
+                  return `{...}`;
+                }
+                return arg.toStringWithSegments(arg.base, arg.segments, {
                   withReturnValues: doRenderNestedFunctionCallReturnValue,
-                }),
-              )
+                });
+              })
               .join(', ');
             result += `(${argsStr})`;
           }

package/analyzer-template/packages/ai/src/lib/completionCall.ts

@@ -134,7 +134,7 @@ export default async function completionCall({
   };
   const params = lib.openai.chatRequestToOpenAIChatParams(chatRequest);
 
-  const chatCompletion = await queue.add(() => {
+  const chatCompletionResult = await queue.add(() => {
     queueEndTime = Date.now();
     return PRetry(
       async () => {
@@ -185,6 +185,12 @@ export default async function completionCall({
       },
     );
   });
+
+  if (!chatCompletionResult) {
+    throw new Error('Completion call returned no result');
+  }
+
+  const chatCompletion = chatCompletionResult;
   const endTime = Date.now();
 
   const llmCallStats = getLLMCallStats({
@@ -304,7 +310,7 @@ ${completion}
 
 Please provide a corrected version with valid JSON only. Do not include any explanatory text, just the valid JSON object.`;
 
-        const correctionChatCompletion = await queue.add(() => {
+        const correctionChatCompletionResult = await queue.add(() => {
           return PRetry(
             async () => {
               const correctionStartTime = Date.now();
@@ -359,6 +365,12 @@ Please provide a corrected version with valid JSON only. Do not include any expl
           );
         });
 
+        if (!correctionChatCompletionResult) {
+          throw new Error('Correction call returned no result');
+        }
+
+        const correctionChatCompletion = correctionChatCompletionResult;
+
         const correctedRawCompletion =
           correctionChatCompletion.choices?.[0]?.message?.content;
 

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -398,6 +398,7 @@ const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
   'transformed non-object function equivalency - Array.from() equivalency',
   'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
   // 'transformed non-object function equivalency - Explicit array deconstruction equivalency value',
+  'useState setter call equivalency (direct)',
 ]);
 
 export class ScopeDataStructure {
@@ -1048,9 +1049,38 @@ export class ScopeDataStructure {
     equivalencyValueChain?: EquivalencyValueChainItem[],
     traceId?: number,
   ) {
+    // Fast early exits that don't count toward the limit.
+    // These are "no-op" calls that would be caught further below anyway,
+    // but checking them first prevents counter inflation from redundant calls
+    // generated by managers and followEquivalencies during scope processing.
+
+    // Skip silently-ignored reasons before counting
+    if (SILENTLY_IGNORED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
+      return;
+    }
+
+    // Skip exact duplicates before counting (Phase 1 only — Phase 2 needs
+    // to process duplicates for database chain tracking)
+    if (this.onlyEquivalencies) {
+      const existing = scopeNode.equivalencies[path];
+      if (
+        existing?.some(
+          (v) =>
+            v.schemaPath === equivalentPath &&
+            v.scopeNodeName === equivalentScopeName,
+        )
+      ) {
+        return;
+      }
+    }
+
     addEquivalencyCallCount++;
 
-    if (addEquivalencyCallCount > 50000) {
+    const limit =
+      typeof (globalThis as any).__CODEYAM_EQUIVALENCY_LIMIT === 'number'
+        ? (globalThis as any).__CODEYAM_EQUIVALENCY_LIMIT
+        : 50000;
+    if (addEquivalencyCallCount > limit) {
       console.error('INFINITE LOOP DETECTED in addEquivalency', {
         callCount: addEquivalencyCallCount,
         path,
@@ -1065,14 +1095,11 @@ export class ScopeDataStructure {
     }
     // Filter equivalency reasons - use pre-computed Sets for O(1) lookup
     if (!ALLOWED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
-      if (SILENTLY_IGNORED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
-        return;
-      } else {
-        // Log and skip - if an equivalency reason isn't in ALLOWED or SILENTLY_IGNORED,
-        // it shouldn't be stored (was previously missing the return)
-        console.info('Not tracked equivalency reason', { equivalencyReason });
-        return;
-      }
+      // Silently-ignored reasons already handled above
+      // Log and skip - if an equivalency reason isn't in ALLOWED or SILENTLY_IGNORED,
+      // it shouldn't be stored (was previously missing the return)
+      console.info('Not tracked equivalency reason', { equivalencyReason });
+      return;
     }
 
     // Skip self-referential equivalencies that would create infinite loops.
@@ -1108,6 +1135,33 @@ export class ScopeDataStructure {
       return;
     }
 
+    // Case 3: Circular reference through scope-suffixed names (____cyScope pattern)
+    // When a named arrow function is defined inside a scope (e.g., useEffect callback):
+    //   const identifyUser = async () => { ... };
+    //   identifyUser();
+    // This creates a variable "identifyUser" and a scope "identifyUser____cyScope9F".
+    // Mutual equivalencies between these cause infinite loops in Phase 2 because
+    // processing one triggers addToSchema → followEquivalencies → addEquivalency
+    // on the reverse, which repeats indefinitely.
+    // Only block when the REVERSE direction already exists (creating a cycle).
+    // The initial one-directional equivalency is necessary for scope resolution.
+    if (
+      path &&
+      equivalentPath &&
+      (equivalentPath.startsWith(path + '____') ||
+        path.startsWith(equivalentPath + '____'))
+    ) {
+      // Check if the reverse equivalency already exists
+      const reverseEquivalencies =
+        scopeNode.equivalencies[equivalentPath] || [];
+      const reverseExists = reverseEquivalencies.some(
+        (v) => v.schemaPath === path,
+      );
+      if (reverseExists) {
+        return;
+      }
+    }
+
     if (!equivalentScopeName) {
       console.error(
         'CodeYam Error: Missing equivalent scope name - FULL CONTEXT:',

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/ParentScopeManager.ts

@@ -97,6 +97,16 @@ export default class ParentScopeManager implements EquivalencyManager {
       }
 
       if (instantiatedInParent || returnValueFromChildScope) {
+        // Skip if we've already propagated this variable to the parent scope.
+        // Without this guard, nested scopes trigger redundant addEquivalency calls
+        // for the same variable on every addToSchema pass (e.g., 'a' and 'b' in sort
+        // callbacks get propagated 30+ times per scope instead of once).
+        this.addedToParent[scopeNode.name] ||= new Set<string>();
+        if (this.addedToParent[scopeNode.name].has(rootPath)) {
+          return false;
+        }
+        this.addedToParent[scopeNode.name].add(rootPath);
+
         if (traceId && debugLevel > 0) {
           console.info(
             'Debug Propagation: parentScope executed',
@@ -114,9 +124,6 @@ export default class ParentScopeManager implements EquivalencyManager {
           );
         }
 
-        this.addedToParent[scopeNode.name] ||= new Set<string>();
-        this.addedToParent[scopeNode.name].add(rootPath);
-
         scopeDataStructure.addEquivalency(
           rootPath,
           rootPath,

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/cleanKnownObjectFunctions.ts

@@ -6,7 +6,7 @@ import { ScopeNode, ScopeDataStructure } from '../ScopeDataStructure';
 
 type PrimitiveKind = 'array' | 'string' | 'number' | 'boolean' | 'date';
 
-const IGNORE_CLASSES_AND_OBJECTS = [
+const IGNORE_CLASSES_AND_OBJECTS_SET = new Set([
   'Math',
   'JSON',
   'Reflect',
@@ -22,7 +22,7 @@ const IGNORE_CLASSES_AND_OBJECTS = [
   'useContext',
   'useReducer',
   'useLayoutEffect',
-];
+]);
 
 /** cache the tokenised representation of every path we touch */
 const partsCache = new Map<string, string[]>();
@@ -147,16 +147,26 @@ function scrub(
   rootTable: Map<string, PrimitiveKind>,
   onRemove: (key: string) => void,
 ): void {
-  const sortedKeys = Object.keys(mapping).sort((a, b) => a.localeCompare(b));
+  // Early exit: if no primitive types exist in the schema, there are no
+  // built-in methods to clean. Saves sorting + walking 10K+ keys.
+  if (rootTable.size === 0) return;
+
+  // Use direct comparison instead of localeCompare (3-5x faster for large arrays)
+  const sortedKeys = Object.keys(mapping).sort((a, b) =>
+    a < b ? -1 : a > b ? 1 : 0,
+  );
 
   for (const keyPath of sortedKeys) {
     const keyParts = getParts(keyPath);
     const prefixParts = buildPrefixParts(keyParts);
 
+    const firstPart = keyParts[0];
+    const firstPartBase = firstPart.includes('(')
+      ? firstPart.split('(')[0]
+      : firstPart;
     if (
-      IGNORE_CLASSES_AND_OBJECTS.find(
-        (m) => keyParts[0] === m || keyParts[0].startsWith(`${m}(`),
-      )
+      IGNORE_CLASSES_AND_OBJECTS_SET.has(firstPart) ||
+      IGNORE_CLASSES_AND_OBJECTS_SET.has(firstPartBase)
     ) {
       delete mapping[keyPath];
       continue;

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/coercePrimitivesToArraysBySchema.ts

@@ -0,0 +1,62 @@
+/**
+ * Coerces primitive values to empty arrays when the schema expects an array.
+ *
+ * The LLM sometimes generates a primitive (boolean, number, string) where the
+ * schema expects an array. For example:
+ *   Schema: { webapps: [{ name: "string" }] }
+ *   LLM output: { webapps: true }
+ *
+ * This causes runtime errors like `TypeError: config.webapps?.forEach is not a function`
+ * because the code expects an array but gets a boolean.
+ *
+ * Coercion rule:
+ * - primitive → array: replace with []
+ *
+ * Null and undefined values are preserved (they may be intentionally nullable).
+ *
+ * @param data The mock data object to coerce (mutated in place)
+ * @param schema The schema describing expected types
+ */
+export default function coercePrimitivesToArraysBySchema<T>(
+  data: T,
+  schema: unknown,
+): T {
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = coercePrimitivesToArraysBySchema(data[i], itemSchema);
+    }
+    return data;
+  }
+
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+
+    if (value === null || value === undefined) {
+      continue;
+    }
+
+    if (typeof value !== 'object' && Array.isArray(fieldSchema)) {
+      // Schema expects an array but the value is a primitive.
+      // Replace with an empty array.
+      dataObj[key] = [];
+    } else if (typeof value === 'object' && value !== null) {
+      // Both value and schema are objects — recurse
+      coercePrimitivesToArraysBySchema(value, fieldSchema);
+    }
+  }
+
+  return data;
+}